package com.liuyz;

public class 自定义泛型 {
}

class Dog<T> {
    private String name;
    private T type;
    // 泛型数组不能直接初始化
    // private T[] types = new T[3];

    public Dog(String name, T type) {
        this.name = name;
        this.type = type;
    }

    // 静态成员中不能使用泛型
    // public static void m1() {
    //     System.out.println(T);
    // }

}

interface Father<K, V> {
    int i = 10;

    // 静态成员不能使用泛型
    // K k;

    K m1(V v);

    V m2(K k);

}

// 接口继承接口时指定泛型类型、定义泛型
interface Son<T> extends Father<String, Integer> {
    T m3();
}

// 在子接口的实现类中会默认进行泛型类型的替换、指定子接口的泛型类型
class A implements Son<Double> {

    @Override
    public String m1(Integer integer) {
        return null;
    }

    @Override
    public Integer m2(String s) {
        return null;
    }

    @Override
    public Double m3() {
        return null;
    }
}

@SuppressWarnings("all")
class B<T> {

    T t1;

    // 泛型方法定义
    public <M, N> void m1(M m, N n) {
        System.out.println(m.getClass());
        System.out.println(n.getClass());
    }

    // 使用泛型的方法不是泛型方法
    public void m2(T t) {
        System.out.println(t.getClass()); // String
        t1 = t;
    }

    public void m3() {
        // System.out.println(t1.getClass()); // String
        System.out.println(t1.getClass()); //
    }

}

class Test {
    public static void main(String[] args) {
        B b = new B();
        // 调用泛型方法时需要指定泛型类型，也就是所传入数据的数据类型
        // b.m1("张三", 65456.55f);
        // b.m2("222");
        // b.m2(new Integer(222));
        b.m3();
    }
}
